home *** CD-ROM | disk | FTP | other *** search
/ Motor Sport Digital Archive Collection 1960s / Motor Sport Digital Archive Collection 1960s.iso / main.swf / scripts / mx / effects / Effect.as < prev    next >
Encoding:
Text File  |  2008-05-21  |  20.0 KB  |  662 lines
  1. package mx.effects
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.EventDispatcher;
  5.    import flash.utils.getQualifiedClassName;
  6.    import mx.core.IFlexDisplayObject;
  7.    import mx.core.mx_internal;
  8.    import mx.effects.effectClasses.AddRemoveEffectTargetFilter;
  9.    import mx.effects.effectClasses.HideShowEffectTargetFilter;
  10.    import mx.effects.effectClasses.PropertyChanges;
  11.    import mx.events.EffectEvent;
  12.    import mx.managers.LayoutManager;
  13.    
  14.    use namespace mx_internal;
  15.    
  16.    public class Effect extends EventDispatcher
  17.    {
  18.       mx_internal static const VERSION:String = "2.0.1.0";
  19.       
  20.       mx_internal var applyActualDimensions:Boolean = true;
  21.       
  22.       private var _instances:Array;
  23.       
  24.       private var _filter:String;
  25.       
  26.       private var _customFilter:EffectTargetFilter;
  27.       
  28.       mx_internal var durationExplicitlySet:Boolean = false;
  29.       
  30.       public var repeatCount:int = 1;
  31.       
  32.       public var repeatDelay:int = 0;
  33.       
  34.       public var suspendBackgroundProcessing:Boolean = false;
  35.       
  36.       public var startDelay:int = 0;
  37.       
  38.       private var _targets:Array;
  39.       
  40.       mx_internal var propertyChangesArray:Array;
  41.       
  42.       private var _relevantProperties:Array;
  43.       
  44.       mx_internal var filterObject:EffectTargetFilter;
  45.       
  46.       private var _callValidateNow:Boolean = false;
  47.       
  48.       mx_internal var initEvent:Event;
  49.       
  50.       public var instanceClass:Class;
  51.       
  52.       private var _duration:Number = 500;
  53.       
  54.       private var _relevantStyles:Array;
  55.       
  56.       private var isPaused:Boolean = false;
  57.       
  58.       public function Effect(param1:Object = null)
  59.       {
  60.          _instances = [];
  61.          _callValidateNow = false;
  62.          isPaused = false;
  63.          mx_internal::applyActualDimensions = true;
  64.          _duration = 500;
  65.          mx_internal::durationExplicitlySet = false;
  66.          _relevantStyles = [];
  67.          instanceClass = IEffectInstance;
  68.          repeatCount = 1;
  69.          repeatDelay = 0;
  70.          startDelay = 0;
  71.          suspendBackgroundProcessing = false;
  72.          _targets = [];
  73.          super();
  74.          this.target = param1;
  75.       }
  76.       
  77.       private static function mergeArrays(param1:Array, param2:Array) : Array
  78.       {
  79.          var _loc3_:int = 0;
  80.          var _loc4_:Boolean = false;
  81.          var _loc5_:int = 0;
  82.          if(param2)
  83.          {
  84.             _loc3_ = 0;
  85.             while(_loc3_ < param2.length)
  86.             {
  87.                _loc4_ = true;
  88.                _loc5_ = 0;
  89.                while(_loc5_ < param1.length)
  90.                {
  91.                   if(param1[_loc5_] == param2[_loc3_])
  92.                   {
  93.                      _loc4_ = false;
  94.                      break;
  95.                   }
  96.                   _loc5_++;
  97.                }
  98.                if(_loc4_)
  99.                {
  100.                   param1.push(param2[_loc3_]);
  101.                }
  102.                _loc3_++;
  103.             }
  104.          }
  105.          return param1;
  106.       }
  107.       
  108.       private static function stripUnchangedValues(param1:Array) : Array
  109.       {
  110.          var _loc2_:int = 0;
  111.          var _loc3_:Object = null;
  112.          _loc2_ = 0;
  113.          while(_loc2_ < param1.length)
  114.          {
  115.             for(_loc3_ in param1[_loc2_].start)
  116.             {
  117.                if(param1[_loc2_].start[_loc3_] == param1[_loc2_].end[_loc3_] || typeof param1[_loc2_].start[_loc3_] == "number" && typeof param1[_loc2_].end[_loc3_] == "number" && isNaN(param1[_loc2_].start[_loc3_]) && isNaN(param1[_loc2_].end[_loc3_]))
  118.                {
  119.                   delete param1[_loc2_].start[_loc3_];
  120.                   delete param1[_loc2_].end[_loc3_];
  121.                }
  122.             }
  123.             _loc2_++;
  124.          }
  125.          return param1;
  126.       }
  127.       
  128.       public function set targets(param1:Array) : void
  129.       {
  130.          var _loc2_:int = 0;
  131.          var _loc3_:int = 0;
  132.          _loc2_ = int(param1.length);
  133.          _loc3_ = _loc2_ - 1;
  134.          while(_loc3_ > 0)
  135.          {
  136.             if(param1[_loc3_] == null)
  137.             {
  138.                param1.splice(_loc3_,1);
  139.             }
  140.             _loc3_--;
  141.          }
  142.          _targets = param1;
  143.       }
  144.       
  145.       public function end(param1:IEffectInstance = null) : void
  146.       {
  147.          var _loc2_:int = 0;
  148.          var _loc3_:int = 0;
  149.          var _loc4_:IEffectInstance = null;
  150.          if(param1)
  151.          {
  152.             param1.end();
  153.          }
  154.          else
  155.          {
  156.             _loc2_ = int(_instances.length);
  157.             _loc3_ = _loc2_;
  158.             while(_loc3_ >= 0)
  159.             {
  160.                _loc4_ = IEffectInstance(_instances[_loc3_]);
  161.                if(_loc4_)
  162.                {
  163.                   _loc4_.end();
  164.                }
  165.                _loc3_--;
  166.             }
  167.          }
  168.       }
  169.       
  170.       protected function filterInstance(param1:Array, param2:Object) : Boolean
  171.       {
  172.          if(mx_internal::filterObject)
  173.          {
  174.             return mx_internal::filterObject.filterFunction(param1,param2);
  175.          }
  176.          return true;
  177.       }
  178.       
  179.       public function get target() : Object
  180.       {
  181.          if(_targets.length > 0)
  182.          {
  183.             return _targets[0];
  184.          }
  185.          return null;
  186.       }
  187.       
  188.       public function get duration() : Number
  189.       {
  190.          return _duration;
  191.       }
  192.       
  193.       protected function getValueFromTarget(param1:Object, param2:String) : *
  194.       {
  195.          if(param2 in param1)
  196.          {
  197.             return param1[param2];
  198.          }
  199.          return undefined;
  200.       }
  201.       
  202.       public function set customFilter(param1:EffectTargetFilter) : void
  203.       {
  204.          _customFilter = param1;
  205.          mx_internal::filterObject = param1;
  206.       }
  207.       
  208.       public function get targets() : Array
  209.       {
  210.          return _targets;
  211.       }
  212.       
  213.       public function captureStartValues() : void
  214.       {
  215.          var _loc1_:int = 0;
  216.          var _loc2_:int = 0;
  217.          if(targets.length > 0)
  218.          {
  219.             mx_internal::propertyChangesArray = [];
  220.             _callValidateNow = true;
  221.             _loc1_ = int(targets.length);
  222.             _loc2_ = 0;
  223.             while(_loc2_ < _loc1_)
  224.             {
  225.                mx_internal::propertyChangesArray.push(new PropertyChanges(targets[_loc2_]));
  226.                _loc2_++;
  227.             }
  228.             mx_internal::propertyChangesArray = mx_internal::captureValues(mx_internal::propertyChangesArray,true);
  229.          }
  230.       }
  231.       
  232.       public function set target(param1:Object) : void
  233.       {
  234.          _targets.splice(0);
  235.          if(param1)
  236.          {
  237.             _targets[0] = param1;
  238.          }
  239.       }
  240.       
  241.       public function get className() : String
  242.       {
  243.          var _loc1_:String = null;
  244.          var _loc2_:int = 0;
  245.          _loc1_ = getQualifiedClassName(this);
  246.          _loc2_ = int(_loc1_.indexOf("::"));
  247.          if(_loc2_ != -1)
  248.          {
  249.             _loc1_ = _loc1_.substr(_loc2_ + 2);
  250.          }
  251.          return _loc1_;
  252.       }
  253.       
  254.       public function get isPlaying() : Boolean
  255.       {
  256.          return Boolean(_instances) && _instances.length > 0;
  257.       }
  258.       
  259.       mx_internal function captureValues(param1:Array, param2:Boolean) : Array
  260.       {
  261.          var _loc3_:Array = null;
  262.          var _loc4_:Object = null;
  263.          var _loc5_:Object = null;
  264.          var _loc6_:int = 0;
  265.          var _loc7_:int = 0;
  266.          var _loc8_:int = 0;
  267.          var _loc9_:int = 0;
  268.          var _loc10_:Array = null;
  269.          _loc3_ = !mx_internal::filterObject ? relevantProperties : mergeArrays(relevantProperties,mx_internal::filterObject.filterProperties);
  270.          if(Boolean(_loc3_) && _loc3_.length > 0)
  271.          {
  272.             _loc6_ = int(param1.length);
  273.             _loc7_ = 0;
  274.             while(_loc7_ < _loc6_)
  275.             {
  276.                _loc5_ = param1[_loc7_].target;
  277.                _loc4_ = param2 ? param1[_loc7_].start : param1[_loc7_].end;
  278.                _loc8_ = int(_loc3_.length);
  279.                _loc9_ = 0;
  280.                while(_loc9_ < _loc8_)
  281.                {
  282.                   _loc4_[_loc3_[_loc9_]] = getValueFromTarget(_loc5_,_loc3_[_loc9_]);
  283.                   _loc9_++;
  284.                }
  285.                _loc7_++;
  286.             }
  287.          }
  288.          _loc10_ = !mx_internal::filterObject ? relevantStyles : mergeArrays(relevantStyles,mx_internal::filterObject.filterStyles);
  289.          if((Boolean(_loc10_)) && _loc10_.length > 0)
  290.          {
  291.             _loc6_ = int(param1.length);
  292.             _loc7_ = 0;
  293.             while(_loc7_ < _loc6_)
  294.             {
  295.                _loc5_ = param1[_loc7_].target;
  296.                _loc4_ = param2 ? param1[_loc7_].start : param1[_loc7_].end;
  297.                _loc8_ = int(_loc10_.length);
  298.                _loc9_ = 0;
  299.                while(_loc9_ < _loc8_)
  300.                {
  301.                   _loc4_[_loc10_[_loc9_]] = _loc5_.getStyle(_loc10_[_loc9_]);
  302.                   _loc9_++;
  303.                }
  304.                _loc7_++;
  305.             }
  306.          }
  307.          return param1;
  308.       }
  309.       
  310.       public function set duration(param1:Number) : void
  311.       {
  312.          mx_internal::durationExplicitlySet = true;
  313.          _duration = param1;
  314.       }
  315.       
  316.       public function get relevantProperties() : Array
  317.       {
  318.          if(_relevantProperties)
  319.          {
  320.             return _relevantProperties;
  321.          }
  322.          return getAffectedProperties();
  323.       }
  324.       
  325.       public function createInstance(param1:Object = null) : IEffectInstance
  326.       {
  327.          var _loc2_:IEffectInstance = null;
  328.          var _loc3_:PropertyChanges = null;
  329.          var _loc4_:Boolean = false;
  330.          var _loc5_:Boolean = false;
  331.          var _loc6_:int = 0;
  332.          var _loc7_:int = 0;
  333.          if(!param1)
  334.          {
  335.             param1 = this.target;
  336.          }
  337.          _loc2_ = null;
  338.          _loc3_ = null;
  339.          _loc4_ = true;
  340.          _loc5_ = false;
  341.          if(mx_internal::propertyChangesArray)
  342.          {
  343.             _loc5_ = true;
  344.             _loc4_ = filterInstance(mx_internal::propertyChangesArray,param1);
  345.          }
  346.          if(_loc4_)
  347.          {
  348.             _loc2_ = IEffectInstance(new instanceClass(param1));
  349.             initInstance(_loc2_);
  350.             if(_loc5_)
  351.             {
  352.                _loc6_ = int(mx_internal::propertyChangesArray.length);
  353.                _loc7_ = 0;
  354.                while(_loc7_ < _loc6_)
  355.                {
  356.                   if(mx_internal::propertyChangesArray[_loc7_].target == param1)
  357.                   {
  358.                      _loc2_.propertyChanges = mx_internal::propertyChangesArray[_loc7_];
  359.                   }
  360.                   _loc7_++;
  361.                }
  362.             }
  363.             EventDispatcher(_loc2_).addEventListener(EffectEvent.EFFECT_START,effectStartHandler);
  364.             EventDispatcher(_loc2_).addEventListener(EffectEvent.EFFECT_END,effectEndHandler);
  365.             _instances.push(_loc2_);
  366.             if(mx_internal::initEvent)
  367.             {
  368.                _loc2_.initEffect(mx_internal::initEvent);
  369.             }
  370.          }
  371.          return _loc2_;
  372.       }
  373.       
  374.       protected function applyValueToTarget(param1:Object, param2:String, param3:*, param4:Object) : void
  375.       {
  376.          var target:Object = param1;
  377.          var property:String = param2;
  378.          var value:* = param3;
  379.          var props:Object = param4;
  380.          if(property in target)
  381.          {
  382.             try
  383.             {
  384.                if(mx_internal::applyActualDimensions && target is IFlexDisplayObject && property == "height")
  385.                {
  386.                   target.setActualSize(target.width,value);
  387.                }
  388.                else if(mx_internal::applyActualDimensions && target is IFlexDisplayObject && property == "width")
  389.                {
  390.                   target.setActualSize(value,target.height);
  391.                }
  392.                else
  393.                {
  394.                   target[property] = value;
  395.                }
  396.             }
  397.             catch(e:Error)
  398.             {
  399.             }
  400.          }
  401.       }
  402.       
  403.       protected function effectStartHandler(param1:EffectEvent) : void
  404.       {
  405.          dispatchEvent(param1);
  406.       }
  407.       
  408.       public function play(param1:Array = null, param2:Boolean = false) : Array
  409.       {
  410.          var _loc3_:Array = null;
  411.          var _loc4_:int = 0;
  412.          var _loc5_:int = 0;
  413.          var _loc6_:IEffectInstance = null;
  414.          if(param1 == null && mx_internal::propertyChangesArray != null)
  415.          {
  416.             if(_callValidateNow)
  417.             {
  418.                LayoutManager.getInstance().validateNow();
  419.             }
  420.             mx_internal::propertyChangesArray = mx_internal::captureValues(mx_internal::propertyChangesArray,false);
  421.             mx_internal::propertyChangesArray = stripUnchangedValues(mx_internal::propertyChangesArray);
  422.             mx_internal::applyStartValues(mx_internal::propertyChangesArray,this.targets);
  423.          }
  424.          _loc3_ = createInstances(param1);
  425.          _loc4_ = int(_loc3_.length);
  426.          _loc5_ = 0;
  427.          while(_loc5_ < _loc4_)
  428.          {
  429.             _loc6_ = IEffectInstance(_loc3_[_loc5_]);
  430.             Object(_loc6_).playReversed = param2;
  431.             _loc6_.startEffect();
  432.             _loc5_++;
  433.          }
  434.          return _loc3_;
  435.       }
  436.       
  437.       public function resume() : void
  438.       {
  439.          var _loc1_:int = 0;
  440.          var _loc2_:int = 0;
  441.          if(isPlaying && isPaused)
  442.          {
  443.             isPaused = false;
  444.             _loc1_ = int(_instances.length);
  445.             _loc2_ = 0;
  446.             while(_loc2_ < _loc1_)
  447.             {
  448.                IEffectInstance(_instances[_loc2_]).resume();
  449.                _loc2_++;
  450.             }
  451.          }
  452.       }
  453.       
  454.       public function set relevantStyles(param1:Array) : void
  455.       {
  456.          _relevantStyles = param1;
  457.       }
  458.       
  459.       public function getAffectedProperties() : Array
  460.       {
  461.          return [];
  462.       }
  463.       
  464.       protected function initInstance(param1:IEffectInstance) : void
  465.       {
  466.          param1.duration = duration;
  467.          Object(param1).durationExplicitlySet = mx_internal::durationExplicitlySet;
  468.          param1.effect = this;
  469.          param1.repeatCount = repeatCount;
  470.          param1.repeatDelay = repeatDelay;
  471.          param1.startDelay = startDelay;
  472.          param1.suspendBackgroundProcessing = suspendBackgroundProcessing;
  473.       }
  474.       
  475.       public function get customFilter() : EffectTargetFilter
  476.       {
  477.          return _customFilter;
  478.       }
  479.       
  480.       mx_internal function applyStartValues(param1:Array, param2:Array) : void
  481.       {
  482.          var _loc3_:Array = null;
  483.          var _loc4_:int = 0;
  484.          var _loc5_:int = 0;
  485.          var _loc6_:int = 0;
  486.          var _loc7_:int = 0;
  487.          var _loc8_:Object = null;
  488.          var _loc9_:Boolean = false;
  489.          _loc3_ = relevantProperties;
  490.          _loc4_ = int(param1.length);
  491.          _loc5_ = 0;
  492.          while(_loc5_ < _loc4_)
  493.          {
  494.             _loc8_ = param1[_loc5_].target;
  495.             _loc9_ = false;
  496.             _loc6_ = int(param2.length);
  497.             _loc7_ = 0;
  498.             while(_loc7_ < _loc6_)
  499.             {
  500.                if(param2[_loc7_] == _loc8_)
  501.                {
  502.                   _loc9_ = filterInstance(param1,_loc8_);
  503.                   break;
  504.                }
  505.                _loc7_++;
  506.             }
  507.             if(_loc9_)
  508.             {
  509.                _loc6_ = int(_loc3_.length);
  510.                _loc7_ = 0;
  511.                while(_loc7_ < _loc6_)
  512.                {
  513.                   if(_loc3_[_loc7_] in param1[_loc5_].start && _loc3_[_loc7_] in _loc8_)
  514.                   {
  515.                      applyValueToTarget(_loc8_,_loc3_[_loc7_],param1[_loc5_].start[_loc3_[_loc7_]],param1[_loc5_].start);
  516.                   }
  517.                   _loc7_++;
  518.                }
  519.                _loc6_ = int(relevantStyles.length);
  520.                _loc7_ = 0;
  521.                while(_loc7_ < _loc6_)
  522.                {
  523.                   if(relevantStyles[_loc7_] in param1[_loc5_].start)
  524.                   {
  525.                      _loc8_.setStyle(relevantStyles[_loc7_],param1[_loc5_].start[relevantStyles[_loc7_]]);
  526.                   }
  527.                   _loc7_++;
  528.                }
  529.             }
  530.             _loc5_++;
  531.          }
  532.       }
  533.       
  534.       public function get relevantStyles() : Array
  535.       {
  536.          return _relevantStyles;
  537.       }
  538.       
  539.       public function set relevantProperties(param1:Array) : void
  540.       {
  541.          _relevantProperties = param1;
  542.       }
  543.       
  544.       public function createInstances(param1:Array = null) : Array
  545.       {
  546.          var _loc2_:Array = null;
  547.          var _loc3_:int = 0;
  548.          var _loc4_:int = 0;
  549.          var _loc5_:IEffectInstance = null;
  550.          if(!param1)
  551.          {
  552.             param1 = this.targets;
  553.          }
  554.          _loc2_ = [];
  555.          _loc3_ = int(param1.length);
  556.          _loc4_ = 0;
  557.          while(_loc4_ < _loc3_)
  558.          {
  559.             _loc5_ = createInstance(param1[_loc4_]);
  560.             if(_loc5_)
  561.             {
  562.                _loc2_.push(_loc5_);
  563.             }
  564.             _loc4_++;
  565.          }
  566.          mx_internal::initEvent = null;
  567.          return _loc2_;
  568.       }
  569.       
  570.       protected function effectEndHandler(param1:EffectEvent) : void
  571.       {
  572.          var _loc2_:IEffectInstance = null;
  573.          var _loc3_:int = 0;
  574.          var _loc4_:int = 0;
  575.          _loc2_ = IEffectInstance(param1.effectInstance);
  576.          EventDispatcher(_loc2_).removeEventListener(EffectEvent.EFFECT_START,effectStartHandler);
  577.          EventDispatcher(_loc2_).removeEventListener(EffectEvent.EFFECT_END,effectEndHandler);
  578.          _loc3_ = int(_instances.length);
  579.          _loc4_ = 0;
  580.          while(_loc4_ < _loc3_)
  581.          {
  582.             if(_instances[_loc4_] === _loc2_)
  583.             {
  584.                _instances.splice(_loc4_,1);
  585.             }
  586.             _loc4_++;
  587.          }
  588.          dispatchEvent(param1);
  589.       }
  590.       
  591.       public function reverse() : void
  592.       {
  593.          var _loc1_:int = 0;
  594.          var _loc2_:int = 0;
  595.          if(isPlaying)
  596.          {
  597.             _loc1_ = int(_instances.length);
  598.             _loc2_ = 0;
  599.             while(_loc2_ < _loc1_)
  600.             {
  601.                IEffectInstance(_instances[_loc2_]).reverse();
  602.                _loc2_++;
  603.             }
  604.          }
  605.       }
  606.       
  607.       public function set filter(param1:String) : void
  608.       {
  609.          if(!customFilter)
  610.          {
  611.             _filter = param1;
  612.             switch(param1)
  613.             {
  614.                case "add":
  615.                case "remove":
  616.                   mx_internal::filterObject = new AddRemoveEffectTargetFilter();
  617.                   AddRemoveEffectTargetFilter(mx_internal::filterObject).add = param1 == "add";
  618.                   break;
  619.                case "hide":
  620.                case "show":
  621.                   mx_internal::filterObject = new HideShowEffectTargetFilter();
  622.                   HideShowEffectTargetFilter(mx_internal::filterObject).show = param1 == "show";
  623.                   break;
  624.                case "move":
  625.                   mx_internal::filterObject = new EffectTargetFilter();
  626.                   mx_internal::filterObject.filterProperties = ["x","y"];
  627.                   break;
  628.                case "resize":
  629.                   mx_internal::filterObject = new EffectTargetFilter();
  630.                   mx_internal::filterObject.filterProperties = ["width","height"];
  631.                   break;
  632.                default:
  633.                   mx_internal::filterObject = null;
  634.             }
  635.          }
  636.       }
  637.       
  638.       public function pause() : void
  639.       {
  640.          var _loc1_:int = 0;
  641.          var _loc2_:int = 0;
  642.          if(isPlaying && !isPaused)
  643.          {
  644.             isPaused = true;
  645.             _loc1_ = int(_instances.length);
  646.             _loc2_ = 0;
  647.             while(_loc2_ < _loc1_)
  648.             {
  649.                IEffectInstance(_instances[_loc2_]).pause();
  650.                _loc2_++;
  651.             }
  652.          }
  653.       }
  654.       
  655.       public function get filter() : String
  656.       {
  657.          return _filter;
  658.       }
  659.    }
  660. }
  661.  
  662.